home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / HotkeyPanel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  14.5 KB  |  707 lines
  1. /*
  2. **    HotkeyPanel.c
  3. **
  4. **    Editing panel for hotkey configuration
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #ifndef _GLOBAL_H
  11. #include "Global.h"
  12. #endif
  13.  
  14. enum    {    GAD_TERMTOFRONT=1,GAD_BUFFERTOFRONT,GAD_SKIPDIAL,GAD_ABORTAREXX,
  15.         GAD_PRIORITY,GAD_HOTKEYS,GAD_USE,GAD_LOAD,GAD_SAVE,GAD_CANCEL,
  16.         GAD_DISCARD
  17.     };
  18.  
  19. STATIC struct Library *KeymapBase;
  20.  
  21.     // All the rawkey codes we know about
  22.  
  23. #define RAWKEY_CURSOR_UP    76
  24. #define RAWKEY_CURSOR_DOWN    77
  25. #define RAWKEY_CURSOR_RIGHT    78
  26. #define RAWKEY_CURSOR_LEFT    79
  27.  
  28. #define RAWKEY_F1        80
  29. #define RAWKEY_F2        81
  30. #define RAWKEY_F3        82
  31. #define RAWKEY_F4        83
  32. #define RAWKEY_F5        84
  33. #define RAWKEY_F6        85
  34. #define RAWKEY_F7        86
  35. #define RAWKEY_F8        87
  36. #define RAWKEY_F9        88
  37. #define RAWKEY_F10        89
  38.  
  39. #define RAWKEY_HELP        95
  40.  
  41. STATIC BOOL
  42. GoodCode(STRPTR Code)
  43. {
  44.     IX Expression;
  45.  
  46.     return((BOOL)(ParseIX(Code,&Expression) == 0));
  47. }
  48.  
  49.     /* EditRoutine():
  50.      *
  51.      *    A special string gadget editing routine for key
  52.      *    combination input.
  53.      */
  54.  
  55. STATIC ULONG __saveds __asm
  56. EditRoutine(REG(a0) struct Hook *Hook,REG(a2) struct SGWork *Work,REG(a1) ULONG *Msg)
  57. {
  58.     struct InputEvent    Event;
  59.     ULONG            Qualifier;
  60.     UWORD            Code;
  61.     UBYTE            Key[10];
  62.     LONG            KeyLen;
  63.     STRPTR            KeyName;
  64.  
  65.         // If the gadget just got activated or the caps lock key
  66.         // is active, don't change anything
  67.  
  68.     if(*Msg == SGH_CLICK || (*Msg == SGH_KEY && (Work -> IEvent -> ie_Qualifier & IEQUALIFIER_CAPSLOCK)))
  69.         return(TRUE);
  70.     else
  71.     {
  72.             // Complain if this is not what we expect to be fun
  73.  
  74.         if(*Msg != SGH_KEY)
  75.             return(FALSE);
  76.     }
  77.  
  78.         // Ditch the qualifier keys
  79.  
  80.     if(Work -> IEvent -> ie_Code >= 96 && Work -> IEvent -> ie_Code <= 103)
  81.     {
  82.         Work -> Actions    &= ~(SGA_USE | SGA_BEEP);
  83.  
  84.         return(TRUE);
  85.     }
  86.  
  87.         // Strip all the qualifiers we don't want
  88.  
  89.     Qualifier = Work -> IEvent -> ie_Qualifier & ~(IEQUALIFIER_REPEAT | IEQUALIFIER_INTERRUPT | IEQUALIFIER_MULTIBROADCAST | IEQUALIFIER_RELATIVEMOUSE);
  90.  
  91.         // Check for raw keys
  92.  
  93.     switch(Work -> IEvent -> ie_Code)
  94.     {
  95.         case RAWKEY_CURSOR_UP:
  96.         case RAWKEY_CURSOR_DOWN:
  97.         case RAWKEY_CURSOR_RIGHT:
  98.         case RAWKEY_CURSOR_LEFT:
  99.  
  100.                 // A cursor key was pressed, check if there
  101.                 // is probably some special feature involved
  102.  
  103.             if(!(Qualifier & ~(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)))
  104.                 return(TRUE);
  105.  
  106.             // FALLS THROUGH TO:
  107.  
  108.         case RAWKEY_F1:
  109.         case RAWKEY_F2:
  110.         case RAWKEY_F3:
  111.         case RAWKEY_F4:
  112.         case RAWKEY_F5:
  113.         case RAWKEY_F6:
  114.         case RAWKEY_F7:
  115.         case RAWKEY_F8:
  116.         case RAWKEY_F9:
  117.         case RAWKEY_F10:
  118.  
  119.         case RAWKEY_HELP:
  120.  
  121.                 // Ok, so this is a raw key event
  122.  
  123.             Code    = Work -> IEvent -> ie_Code;
  124.             KeyLen    = 0;
  125.  
  126.             break;
  127.  
  128.         default:
  129.  
  130.                 // Make a copy of the inputevent and
  131.                 // clear the qualifier bits
  132.  
  133.             CopyMem(Work -> IEvent,&Event,sizeof(struct InputEvent));
  134.  
  135.             Event . ie_Qualifier = NULL;
  136.  
  137.             Code = 0;
  138.  
  139.                 // Translate the event
  140.  
  141.             if((KeyLen = MapRawKey(&Event,Key,10,NULL)) < 0)
  142.                 KeyLen = 10;
  143.  
  144.             break;
  145.     }
  146.  
  147.         // Is the user holding down a single Amiga key?
  148.  
  149.     if(KeyLen && (Qualifier & IEQUALIFIER_RCOMMAND) && !(Qualifier & ~IEQUALIFIER_RCOMMAND))
  150.     {
  151.         LONG Char = ToUpper(Key[0]);
  152.  
  153.             // Undo and clear are supported
  154.  
  155.         if(Char == 'Q' || Char == 'X')
  156.             return(TRUE);
  157.     }
  158.  
  159.         // Can we safely continue?
  160.  
  161.     if((!Code && !KeyLen) || KeyLen > 1 || (!Code && KeyLen && !Key[0]))
  162.     {
  163.         Work -> Actions    = (Work -> Actions & ~SGA_USE) | SGA_BEEP;
  164.  
  165.         return(TRUE);
  166.     }
  167.  
  168.         // Take care of special characters
  169.  
  170.     if(KeyLen)
  171.     {
  172.         STATIC struct { UBYTE Code; STRPTR Name; } KeyTable[] =
  173.         {
  174.             '\r',    "Return",
  175.             '\b',    "Backspace",
  176.             '\033',    "Escape",
  177.             ' ',    "Spacebar",
  178.             ',',    "Comma",
  179.             '\177',    "Delete",
  180.             '\t',    "Tab",
  181.  
  182.             0
  183.         };
  184.  
  185.         BOOL GotIt = FALSE;
  186.         LONG i;
  187.  
  188.             // Carriage return was pressed
  189.  
  190.         if(Key[0] == '\r')
  191.         {
  192.                 // This probably ends input
  193.  
  194.             if(!Qualifier)
  195.             {
  196.                 Work -> Actions    = (Work -> Actions & ~SGA_BEEP) | SGA_USE | SGA_END;
  197.  
  198.                 return(TRUE);
  199.             }
  200.             else
  201.             {
  202.                     // Is this the enter key?
  203.  
  204.                 if(Qualifier & IEQUALIFIER_NUMERICPAD)
  205.                 {
  206.                     KeyName = "Enter";
  207.  
  208.                     Qualifier &= ~IEQUALIFIER_NUMERICPAD;
  209.  
  210.                     GotIt = TRUE;
  211.                 }
  212.             }
  213.         }
  214.  
  215.             // If this is just the tab key, pass it through cleanly
  216.  
  217.         if(Key[0] == '\t' && !(Qualifier & ~(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)))
  218.             return(TRUE);
  219.  
  220.             // Now check for special characters
  221.  
  222.         Key[0] = ToUpper(Key[0]);
  223.  
  224.         if(!GotIt)
  225.         {
  226.             for(i = 0 ; KeyTable[i] . Code ; i++)
  227.             {
  228.                 if(KeyTable[i] . Code == Key[0])
  229.                 {
  230.                     KeyName = KeyTable[i] . Name;
  231.  
  232.                     GotIt = TRUE;
  233.  
  234.                     break;
  235.                 }
  236.             }
  237.         }
  238.  
  239.             // If no special character is involved,
  240.             // use the vanilla character code
  241.  
  242.         if(!GotIt)
  243.         {
  244.             if((Key[0] > ' ' && Key[0] < 127) || Key[0] >= 160)
  245.             {
  246.                 Key[1] = 0;
  247.  
  248.                 KeyName = Key;
  249.             }
  250.             else
  251.             {
  252.                 Work -> Actions    = (Work -> Actions & ~SGA_USE) | SGA_BEEP;
  253.  
  254.                 return(TRUE);
  255.             }
  256.         }
  257.     }
  258.     else
  259.     {
  260.             // Special raw key code table
  261.  
  262.         STATIC struct { UWORD Code; STRPTR Name; } RawTable[] =
  263.         {
  264.             RAWKEY_CURSOR_UP,    "Cursor_Up",
  265.             RAWKEY_CURSOR_DOWN,    "Cursor_Down",
  266.             RAWKEY_CURSOR_RIGHT,    "Cursor_Right",
  267.             RAWKEY_CURSOR_LEFT,    "Cursor_Left",
  268.  
  269.             RAWKEY_F1,        "F1",
  270.             RAWKEY_F2,        "F2",
  271.             RAWKEY_F3,        "F3",
  272.             RAWKEY_F4,        "F4",
  273.             RAWKEY_F5,        "F5",
  274.             RAWKEY_F6,        "F6",
  275.             RAWKEY_F7,        "F7",
  276.             RAWKEY_F8,        "F8",
  277.             RAWKEY_F9,        "F9",
  278.             RAWKEY_F10,        "F10",
  279.  
  280.             RAWKEY_HELP,        "Help",
  281.  
  282.             0
  283.         };
  284.  
  285.         LONG i;
  286.  
  287.             // One eventually must match
  288.  
  289.         for(i = 0 ; RawTable[i] . Code ; i++)
  290.         {
  291.             if(Code == RawTable[i] . Code)
  292.             {
  293.                 KeyName = RawTable[i] . Name;
  294.  
  295.                 break;
  296.             }
  297.         }
  298.     }
  299.  
  300.         // Take care of the qualifiers. Note that we do not distinguish
  301.         // between the left and right shift/alt keys
  302.  
  303.     if(Qualifier)
  304.     {
  305.         STATIC struct { ULONG Qualifier; STRPTR Name; } QualifierTable[] =
  306.         {
  307.             IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT,    "Shift ",
  308.             IEQUALIFIER_LALT | IEQUALIFIER_RALT,        "Alt ",
  309.             IEQUALIFIER_LCOMMAND,                "LAmiga ",
  310.             IEQUALIFIER_RCOMMAND,                "RAmiga ",
  311.             IEQUALIFIER_LEFTBUTTON,                "Left_Button ",
  312.             IEQUALIFIER_MIDBUTTON,                "Middle_Button ",
  313.             IEQUALIFIER_RBUTTON,                "Right_Button ",
  314.             IEQUALIFIER_NUMERICPAD,                "Numeric_Pad ",
  315.  
  316.             0
  317.         };
  318.  
  319.         LONG i;
  320.  
  321.             // Ok, now start building the string
  322.  
  323.         Work -> WorkBuffer[0] = 0;
  324.  
  325.         for(i = 0 ; QualifierTable[i] . Qualifier ; i++)
  326.         {
  327.             if(Qualifier & QualifierTable[i] . Qualifier)
  328.                 strcat(Work -> WorkBuffer,QualifierTable[i] . Name);
  329.         }
  330.  
  331.             // Add the key itself
  332.  
  333.         strcat(Work -> WorkBuffer,KeyName);
  334.  
  335.             // Update the work data
  336.  
  337.         Work -> NumChars    = strlen(Work -> WorkBuffer);
  338.         Work -> BufferPos    = Work -> NumChars;
  339.  
  340.             // Finished...
  341.  
  342.         Work -> Actions    = (Work -> Actions & ~(SGA_BEEP | SGA_PREVACTIVE | SGA_NEXTACTIVE | SGA_END)) | SGA_REDISPLAY | SGA_USE;
  343.     }
  344.     else
  345.         Work -> Actions    &= ~(SGA_USE | SGA_BEEP);
  346.  
  347.     return(TRUE);
  348. }
  349.  
  350. BOOL
  351. HotkeyPanelConfig(struct Configuration *LocalConfig,struct Hotkeys *Hotkeys,STRPTR LastKeys,BOOLEAN *ChangePtr)
  352. {
  353.     STATIC struct Hook EditHook = { {NULL}, (HOOKFUNC)EditRoutine };
  354.  
  355.     struct LayoutHandle    *Handle;
  356.     struct Hotkeys         PrivateHotkeys;
  357.     BOOL             Changed = FALSE;
  358.  
  359.     KeymapBase = OpenLibrary("keymap.library",0);
  360.  
  361.     CopyMem(Hotkeys,&PrivateHotkeys,sizeof(struct Hotkeys));
  362.  
  363.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  364.         LH_LocaleHook,    &LocaleHook,
  365.         LH_ExitFlush,    FALSE,
  366.     TAG_DONE))
  367.     {
  368.         struct Window *PanelWindow;
  369.  
  370.         LT_New(Handle,
  371.             LA_Type,    VERTICAL_KIND,
  372.         TAG_DONE);
  373.         {
  374.             LT_New(Handle,
  375.                 LA_Type,    VERTICAL_KIND,
  376.                 LA_LabelID,    MSG_V36_0083,
  377.             TAG_DONE);
  378.             {
  379.                 LT_New(Handle,
  380.                     LA_Type,    STRING_KIND,
  381.                     LA_LabelID,    MSG_HOTKEYPANEL_TERM_SCREEN_TO_FRONT_GAD,
  382.                     LA_STRPTR,    PrivateHotkeys . termScreenToFront,
  383.                     LA_Chars,    30,
  384.                     GTST_MaxChars,    255,
  385.                     LA_ID,        GAD_TERMTOFRONT,
  386.  
  387.                     KeymapBase ? GTST_EditHook : TAG_IGNORE,&EditHook,
  388.                 TAG_DONE);
  389.  
  390.                 LT_New(Handle,
  391.                     LA_Type,    STRING_KIND,
  392.                     LA_LabelID,    MSG_HOTKEYPANEL_BUFFER_SCREEN_TO_FRONT_GAD,
  393.                     LA_STRPTR,    PrivateHotkeys . BufferScreenToFront,
  394.                     GTST_MaxChars,    255,
  395.                     LA_ID,        GAD_BUFFERTOFRONT,
  396.  
  397.                     KeymapBase ? GTST_EditHook : TAG_IGNORE,&EditHook,
  398.                 TAG_DONE);
  399.  
  400.                 LT_New(Handle,
  401.                     LA_Type,    STRING_KIND,
  402.                     LA_LabelID,    MSG_HOTKEYPANEL_SKIP_DIAL_ENTRY_GAD,
  403.                     LA_STRPTR,    PrivateHotkeys . SkipDialEntry,
  404.                     GTST_MaxChars,    255,
  405.                     LA_ID,        GAD_SKIPDIAL,
  406.  
  407.                     KeymapBase ? GTST_EditHook : TAG_IGNORE,&EditHook,
  408.                 TAG_DONE);
  409.  
  410.                 LT_New(Handle,
  411.                     LA_Type,    STRING_KIND,
  412.                     LA_LabelID,    MSG_HOTKEYPANEL_ABORT_AREXX_GAD,
  413.                     LA_STRPTR,    PrivateHotkeys . AbortARexx,
  414.                     GTST_MaxChars,    255,
  415.                     LA_ID,        GAD_ABORTAREXX,
  416.  
  417.                     KeymapBase ? GTST_EditHook : TAG_IGNORE,&EditHook,
  418.                 TAG_DONE);
  419.  
  420.                 LT_EndGroup(Handle);
  421.             }
  422.  
  423.             LT_New(Handle,
  424.                 LA_Type,        VERTICAL_KIND,
  425.                 LA_LabelID,        MSG_V36_0084,
  426.             TAG_DONE);
  427.             {
  428.                 LT_New(Handle,
  429.                     LA_Type,        SliderType,
  430.                     LA_LabelID,        MSG_HOTKEYPANEL_COMMODITY_PRIORITY_GAD,
  431.                     LA_BYTE,        &PrivateHotkeys . CommodityPriority,
  432.                     GTSL_Min,        -128,
  433.                     GTSL_Max,        127,
  434.                     GTSL_LevelFormat,    "%4ld",
  435.                     LA_Chars,        16,
  436.                     LA_ID,            GAD_PRIORITY,
  437.                 TAG_DONE);
  438.  
  439.                 LT_New(Handle,
  440.                     LA_Type,    CHECKBOX_KIND,
  441.                     LA_LabelID,    MSG_HOTKEYPANEL_HOTKEYS_ENABLED_GAD,
  442.                     LA_BYTE,    &PrivateHotkeys . HotkeysEnabled,
  443.                     LA_ID,        GAD_HOTKEYS,
  444.                 TAG_DONE);
  445.  
  446.                 LT_EndGroup(Handle);
  447.             }
  448.  
  449.             LT_New(Handle,
  450.                 LA_Type,VERTICAL_KIND,
  451.             TAG_DONE);
  452.             {
  453.                 LT_New(Handle,
  454.                     LA_Type,    XBAR_KIND,
  455.                     LAXB_FullSize,    TRUE,
  456.                 TAG_DONE);
  457.  
  458.                 LT_EndGroup(Handle);
  459.             }
  460.  
  461.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  462.                 LAGR_SameSize,    TRUE,
  463.                 LAGR_Spread,    TRUE,
  464.             TAG_DONE);
  465.             {
  466.                 LT_New(Handle,
  467.                     LA_Type,    BUTTON_KIND,
  468.                     LA_LabelID,    MSG_GLOBAL_USE_GAD,
  469.                     LA_ID,        GAD_USE,
  470.                     LABT_ReturnKey,    TRUE,
  471.                     LABT_ExtraFat,    TRUE,
  472.                 TAG_DONE);
  473.  
  474.                 LT_New(Handle,
  475.                     LA_Type,    BUTTON_KIND,
  476.                     LA_LabelID,    MSG_GLOBAL_LOAD_GAD,
  477.                     LA_ID,        GAD_LOAD,
  478.                 TAG_DONE);
  479.  
  480.                 LT_New(Handle,
  481.                     LA_Type,    BUTTON_KIND,
  482.                     LA_LabelID,    MSG_GLOBAL_SAVE_GAD,
  483.                     LA_ID,        GAD_SAVE,
  484.                 TAG_DONE);
  485.  
  486.                 LT_New(Handle,
  487.                     LA_Type,    BUTTON_KIND,
  488.                     LA_LabelID,    MSG_DISCARD_GAD,
  489.                     LA_ID,        GAD_DISCARD,
  490.                 TAG_DONE);
  491.  
  492.                 LT_New(Handle,
  493.                     LA_Type,    BUTTON_KIND,
  494.                     LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  495.                     LA_ID,        GAD_CANCEL,
  496.                     LABT_EscKey,    TRUE,
  497.                 TAG_DONE);
  498.  
  499.                 LT_EndGroup(Handle);
  500.             }
  501.  
  502.             LT_EndGroup(Handle);
  503.         }
  504.  
  505.         if(PanelWindow = LT_Build(Handle,
  506.             LAWN_TitleID,        MSG_HOTKEYPANEL_HOTKEY_PREFERENCES_TXT,
  507.             LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  508.             LAWN_HelpHook,        &GuideHook,
  509.             LAWN_Parent,        Window,
  510.             WA_DepthGadget,        TRUE,
  511.             WA_CloseGadget,        TRUE,
  512.             WA_DragBar,        TRUE,
  513.             WA_RMBTrap,        TRUE,
  514.             WA_Activate,        TRUE,
  515.             WA_SimpleRefresh,    TRUE,
  516.         TAG_DONE))
  517.         {
  518.             struct IntuiMessage    *Message;
  519.             BOOL             Done = FALSE;
  520.             ULONG             MsgClass;
  521.             struct Gadget        *MsgGadget;
  522.  
  523.             struct FileRequester    *FileRequest;
  524.             UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  525.                         *DummyChar;
  526.  
  527.             STRPTR             String;
  528.  
  529.             GuideContext(CONTEXT_HOTKEYS);
  530.  
  531.             PushWindow(PanelWindow);
  532.  
  533.             do
  534.             {
  535.                 if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  536.                 {
  537.                     Changed = FALSE;
  538.  
  539.                     break;
  540.                 }
  541.  
  542.                 while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  543.                 {
  544.                     MsgClass    = Message -> Class;
  545.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  546.  
  547.                     LT_ReplyIMsg(Message);
  548.  
  549.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  550.                     {
  551.                         Changed = FALSE;
  552.                         Done = TRUE;
  553.                     }
  554.  
  555.                     if(MsgClass == IDCMP_GADGETUP)
  556.                     {
  557.                         switch(MsgGadget -> GadgetID)
  558.                         {
  559.                             case GAD_TERMTOFRONT:
  560.                             case GAD_BUFFERTOFRONT:
  561.                             case GAD_SKIPDIAL:
  562.                             case GAD_ABORTAREXX:
  563.  
  564.                                 String = LT_GetString(Handle,MsgGadget -> GadgetID);
  565.  
  566.                                 if(!GoodCode(String))
  567.                                 {
  568.                                     DisplayBeep(PanelWindow -> WScreen);
  569.  
  570.                                     LT_Activate(Handle,MsgGadget -> GadgetID);
  571.                                 }
  572.  
  573.                                 break;
  574.  
  575.                             case GAD_USE:
  576.  
  577.                                 LT_UpdateStrings(Handle);
  578.  
  579.                                 CopyMem(&PrivateHotkeys,Hotkeys,sizeof(struct Hotkeys));
  580.  
  581.                                 Changed = TRUE;
  582.  
  583.                                 if(ChangePtr)
  584.                                     *ChangePtr = TRUE;
  585.  
  586.                                 Done = TRUE;
  587.                                 break;
  588.  
  589.                             case GAD_DISCARD:
  590.  
  591.                                 if(ChangePtr)
  592.                                     *ChangePtr = FALSE;
  593.  
  594.                                 LastKeys[0] = 0;
  595.                                 Changed = Done = TRUE;
  596.  
  597.                                 if(LocalConfig)
  598.                                     strcpy(LocalConfig->HotkeyFileName,LastKeys);
  599.  
  600.                                 break;
  601.  
  602.                             case GAD_CANCEL:
  603.  
  604.                                 Changed = FALSE;
  605.                                 Done = TRUE;
  606.                                 break;
  607.  
  608.                             case GAD_LOAD:
  609.  
  610.                                 SplitFileName(LastKeys,&DummyChar,DummyBuffer);
  611.  
  612.                                 LT_LockWindow(PanelWindow);
  613.  
  614.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_HOTKEYPANEL_LOAD_HOTKEYS_TXT),DummyBuffer,FilePart(LastKeys),DummyBuffer,"#?.prefs",FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_LOAD_TXT),TRUE))
  615.                                 {
  616.                                     if(!LoadHotkeys(DummyBuffer,&PrivateHotkeys))
  617.                                         ShowError(PanelWindow,ERR_LOAD_ERROR,IoErr(),DummyBuffer);
  618.                                     else
  619.                                     {
  620.                                         strcpy(LastKeys,DummyBuffer);
  621.  
  622.                                         if(LocalConfig)
  623.                                             strcpy(LocalConfig->HotkeyFileName,LastKeys);
  624.  
  625.                                         LT_SetAttributes(Handle,GAD_TERMTOFRONT,
  626.                                             GTST_String,PrivateHotkeys . termScreenToFront,
  627.                                         TAG_DONE);
  628.  
  629.                                         LT_SetAttributes(Handle,GAD_BUFFERTOFRONT,
  630.                                             GTST_String,PrivateHotkeys . BufferScreenToFront,
  631.                                         TAG_DONE);
  632.  
  633.                                         LT_SetAttributes(Handle,GAD_SKIPDIAL,
  634.                                             GTST_String,PrivateHotkeys . SkipDialEntry,
  635.                                         TAG_DONE);
  636.  
  637.                                         LT_SetAttributes(Handle,GAD_ABORTAREXX,
  638.                                             GTST_String,PrivateHotkeys . AbortARexx,
  639.                                         TAG_DONE);
  640.  
  641.                                         LT_SetAttributes(Handle,GAD_PRIORITY,
  642.                                             GTSL_Level,PrivateHotkeys . CommodityPriority,
  643.                                         TAG_DONE);
  644.  
  645.                                         LT_SetAttributes(Handle,GAD_HOTKEYS,
  646.                                             GTCB_Checked,PrivateHotkeys . HotkeysEnabled,
  647.                                         TAG_DONE);
  648.  
  649.                                         Changed = TRUE;
  650.  
  651.                                         if(ChangePtr)
  652.                                             *ChangePtr = FALSE;
  653.                                     }
  654.  
  655.                                     FreeAslRequest(FileRequest);
  656.                                 }
  657.  
  658.                                 LT_UnlockWindow(PanelWindow);
  659.  
  660.                                 break;
  661.  
  662.                             case GAD_SAVE:
  663.  
  664.                                 LT_UpdateStrings(Handle);
  665.  
  666.                                 SplitFileName(LastKeys,&DummyChar,DummyBuffer);
  667.  
  668.                                 LT_LockWindow(PanelWindow);
  669.  
  670.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_HOTKEYPANEL_SAVE_HOTKEYS_TXT),DummyBuffer,FilePart(LastKeys),DummyBuffer,"#?.prefs",TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SAVE_TXT),TRUE))
  671.                                 {
  672.                                     if(!WriteIFFData(DummyBuffer,&PrivateHotkeys,sizeof(struct Hotkeys),ID_HOTK))
  673.                                         ShowError(PanelWindow,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  674.                                     else
  675.                                     {
  676.                                         strcpy(LastKeys,DummyBuffer);
  677.  
  678.                                         if(LocalConfig)
  679.                                             strcpy(LocalConfig->HotkeyFileName,LastKeys);
  680.  
  681.                                         if(ChangePtr)
  682.                                             *ChangePtr = FALSE;
  683.                                     }
  684.  
  685.                                     FreeAslRequest(FileRequest);
  686.                                 }
  687.  
  688.                                 LT_UnlockWindow(PanelWindow);
  689.  
  690.                                 break;
  691.                         }
  692.                     }
  693.                 }
  694.             }
  695.             while(!Done);
  696.  
  697.             PopWindow();
  698.         }
  699.  
  700.         LT_DeleteHandle(Handle);
  701.     }
  702.  
  703.     CloseLibrary(KeymapBase);
  704.  
  705.     return(Changed);
  706. }
  707.